package com.android.sq.zouqi.bdmap;

/*
 * 在MapView上有两个图层myloc_overlay, pin_overlay和newloc_overlay
 * pin_overlay主要用来显示所选择的地点（包括如果是修改的状态的从pScrEventInfo传过来的地点和通过长按来选择的新地点）
 * newloc_overlay主要用来通过监听长按事件，来产生一个GeoPoint值，然后生成一个新的OverlayItem加到pin_overlay上去
 * 然后在MapView上显示出来
 * 
 * 在LongPressOverlay的长按时间中获取pin_point
 * 在MKSearch搜索模块中获取pin_address
 * 
 * 逻辑：
 * 	如果是新建，先定位手持者的myloc_point，获取之后再获取这个point的地址
 * 	如果是修改，显示活动的point
 */
import java.util.List;

import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.graphics.drawable.Drawable;
import android.location.Location;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup.LayoutParams;
import android.widget.Button;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.android.sq.zouqi.Constants;
import com.android.sq.zouqi.R;
import com.android.sq.zouqi.event.pScrEventInfo;
import com.baidu.mapapi.BMapManager;
import com.baidu.mapapi.GeoPoint;
import com.baidu.mapapi.LocationListener;
import com.baidu.mapapi.MKAddrInfo;
import com.baidu.mapapi.MKBusLineResult;
import com.baidu.mapapi.MKDrivingRouteResult;
import com.baidu.mapapi.MKPoiResult;
import com.baidu.mapapi.MKSearch;
import com.baidu.mapapi.MKSearchListener;
import com.baidu.mapapi.MKSuggestionResult;
import com.baidu.mapapi.MKTransitRouteResult;
import com.baidu.mapapi.MKWalkingRouteResult;
import com.baidu.mapapi.MapActivity;
import com.baidu.mapapi.MapController;
import com.baidu.mapapi.MapView;
import com.baidu.mapapi.MyLocationOverlay;
import com.baidu.mapapi.Overlay;
import com.baidu.mapapi.OverlayItem;

public class pScrChooseLocation extends MapActivity implements OnClickListener {
	private final static String TAG = "pScrChooseLocation";
	private BMapApp app;
	private boolean isDataNull = false;					// 是新建还是修改的标志位
	MapView mapView = null;								// 百度地图View	
	private List<Overlay> mapOverlays;					// 即MapView中所存有的Overlay图层都是放在这里的
	public MapController mapCtrl;						// 地图控制器	
	private MKSearch mSearch;							// 百度地图搜索模块
	
	private Drawable pin;								// 图钉图片资源
	Button search_btn, location_btn, save_btn;			// 三个按钮
	
	private MyLocationOverlay 	myloc_overlay;			// 定位图层
	private PinOverlay 			pin_overlay;			// 定位修改，用图钉显示这个位置
	private LongPressOverlay 	lngpress_overlay;		// 响应长按事件的图层
	
	private LocationListener mLocationListener;			// 定位的监听器
	
	// 地图当前中心点和地址，是需要传送给pScrEventInfo，用于填充相应的View
	GeoPoint pin_point;									// 当前选择的经纬度
	private String pin_address;							// 当前经纬度的地址
	GeoPoint myloc_point;								// 当前手持者的经纬度
	
	private OverlayItem pin_overlay_item;				// 用于图钉的一个OverlayItem
	
	public View popView;
	int iZoom = 0;
	
	private final static int DIALOG_SEARCH_RESULT = 0;
	
	public final static int MSG_VIEW_LONGPRESS = 0;		// 在LongPressOverlay中长按事件中发送这个消息给handler
	public final static int MSG_SHOW_SEARCH_RESULT = 1;	// 在MKSearch中获取到结果之后发送这个消息给handler，进行PopView的UI信息更新
	public final static int MSG_NO_SEARCH_RESULT = 2;	// 通知主线程MKSearch模块出错，无搜索结果
	public final static int MSG_GET_MYLOCATION_ADDRESS = 3;	//当定位到手持者的当前位置之后，发送这个位置给handler进行获取当前位置的地址
	
	int count = 0;
	boolean hasPin = false;								// 是否有图钉，即PinOverlay是否已经添加到mapOverlays中
	boolean isCurLocate = false;
	
	public Handler handler = new Handler() {
		public void handleMessage(Message msg) {
			TextView titleTV, textTV;
			switch (msg.what) {
			case MSG_VIEW_LONGPRESS:
				if (pin_point != null) {
					mSearch.reverseGeocode(pin_point);
					if (!hasPin) {
						mapOverlays.add(pin_overlay);
						hasPin = true;
					}
					// 构造一个加载OverlayItem，当搜索模块获取到结果，再改变PopView的内容
					OverlayItem load_overlayItem = new OverlayItem(pin_point, "地址名称",
							"正在地址加载...");
					if(pin_overlay.size() > 0){
						pin_overlay.removeOverlay(0);
					}
					popView.setVisibility(View.VISIBLE);
					pin_overlay.addOverlay(load_overlayItem);
					pin_overlay.setFocus(load_overlayItem);
					pin_overlay.updateOverlay();
				}
				break;
			case MSG_NO_SEARCH_RESULT:
				titleTV = (TextView) popView.findViewById(R.id.loc_title);
				textTV  = (TextView) popView.findViewById(R.id.loc_text);
				titleTV.setText("错误提示");
				textTV.setText(msg.obj.toString());
				popView.setVisibility(View.VISIBLE);
				break;
			case MSG_SHOW_SEARCH_RESULT:	// 显示从服务器上获取的地址，并传给pin_point和loc_addr
				// 设置获取的地理信息内容, 需要返回给pScrEventInfo
				/*
				 * 删除PinOverlay中第一个OverlayItem（即长按时显示的地址加载中...的OverlayItem）
				 * 构造一个新OverlayItem加到PinOverlay中去
				 */
				if (pin_overlay.size() > 0) {
					pin_overlay.removeOverlay(0);
				}
				OverlayItem pin_overlayItem;
				Log.e(TAG, "在展示地址之前，isCurLocate=" + isCurLocate);
				if (isCurLocate) {
					Log.e(TAG, "myloc_point=" + myloc_point.getLatitudeE6() + ", " + myloc_point.getLongitudeE6());
					pin_overlayItem = new OverlayItem(myloc_point, "当前位置", pin_address);
				} else {
					Log.e(TAG, "pin_point="+ pin_point.getLatitudeE6() + ", " + pin_point.getLongitudeE6());
					pin_overlayItem = new OverlayItem(pin_point, "地址名称", pin_address);
				}
				
				popView.setVisibility(View.VISIBLE);
				pin_overlay.addOverlay(pin_overlayItem);
				pin_overlay.setFocus(pin_overlayItem);
				pin_overlay.updateOverlay();
				break;
			case MSG_GET_MYLOCATION_ADDRESS:
				mSearch.reverseGeocode(myloc_point);
					mapOverlays.add(pin_overlay);
					hasPin = true;
				isCurLocate = true;
				// 构造一个加载OverlayItem，当搜索模块获取到结果，再改变PopView的内容
				OverlayItem load_overlayItem = new OverlayItem(myloc_point, "地址名称",
						"正在地址加载...");
				if(pin_overlay.size() > 0){
					pin_overlay.removeOverlay(0);
				}
				popView.setVisibility(View.VISIBLE);
				pin_overlay.addOverlay(load_overlayItem);
				pin_overlay.setFocus(load_overlayItem);
				pin_overlay.updateOverlay();
				break;
			}
		}
	};
	
	@Override
	public void onCreate(Bundle SavedInstanceState) {
		super.onCreate(SavedInstanceState);
		setContentView(R.layout.scrmain_event_map);
		app = (BMapApp)this.getApplication();
		if (app.mBMapMan == null) {
			app.mBMapMan = new BMapManager(getApplication());
			app.mBMapMan.init(app.mStrKey, new BMapApp.MyGeneralListener());
		}
		app.mBMapMan.start();
        // 如果使用地图SDK，请初始化地图Activity
        super.initMapActivity(app.mBMapMan);
        // 初始化与MapView相关的一些变量
        mapView = (MapView)findViewById(R.id.bmapView);
		mapCtrl = mapView.getController();
        mapView.setBuiltInZoomControls(true);
        mapView.setDrawOverlayWhenZooming(true);	//设置在缩放动画过程中也显示overlay,默认为不绘制
		iZoom = mapView.getZoomLevel();
		mapOverlays = mapView.getOverlays();
        getBundleData();	// 获取上一个Act的数据
		initPopView();		// 创建点击图钉的弹出泡泡
        // 得到用于标注当前活动地点的图标资源-图钉pin，并为图钉定义位置和边界
     	pin = getResources().getDrawable(R.drawable.pin);
     	pin.setBounds(0, 0, pin.getIntrinsicWidth(), pin.getIntrinsicHeight());
     	
     	// 初始化图钉图层PinOverlay
     	pin_overlay = new PinOverlay(pin, this, mapView, popView, mapCtrl);
        // 用于长按事件响应的一个透明Overlay
        lngpress_overlay = new LongPressOverlay(this, mapView, handler, mapCtrl);
		mapOverlays.add(lngpress_overlay);
		// 添加定位图层MyLocationOverlay，用于定位的时候的展示，是一个蓝色点的圈圈
        myloc_overlay = new MyLocationOverlay(this, mapView);
        mapOverlays.add(myloc_overlay);
        
        // 注册定位监听模块
        mLocationListener = new LocationListener() {
			@Override
			public void onLocationChanged(Location location) {
				// TODO Auto-generated method stub
				if(location != null){
					// 获取到定位之后，手持者的地理经纬度，并传送给handler进行UI更新展示
					myloc_point = new GeoPoint((int)(location.getLatitude()*1e6), 
							(int)(location.getLongitude()*1e6));
					// (30******, 120******)，不是小数点形式
					Log.e(TAG, "定位收到服务器:" + myloc_point.toString());
					mapCtrl.animateTo(myloc_point);
					// 并取消定位的监听，否则会10s定位一次
					app.mBMapMan.getLocationManager().removeUpdates(mLocationListener);
					// 获取到经纬度之后，去获取地址
					handler.sendEmptyMessage(MSG_GET_MYLOCATION_ADDRESS);
				}
			}
        };
        
		// 初始化搜索模块，注册事件监听
        mSearch = new MKSearch();
        mSearch.init(app.mBMapMan, new MKSearchListener(){
			public void onGetAddrResult(MKAddrInfo res, int error) {
				if (error != 0) {
					// 发消息给handler进行错误信息提示
					Message msg = new Message();
					msg.what = MSG_NO_SEARCH_RESULT;
					msg.obj = "查询错误，请重新选择地址！";
					handler.sendMessage(msg);
					return;
				}
				/*
				 * 定位地图到图钉的方位
				 * 把通过搜索模块查询到的经纬度信息发送到handler，进行数据展示和UI更新
				 */
				mapView.getController().animateTo(res.geoPt);
				// 注意：res中的strAddr不为空，
				// 但是res.poiList有可能为空，所以只把strAddr作为所需的地址消息内容，
				// 传给handler进行展示，并传给pScrEventInfo进行展示
				Message msg = new Message();
				msg.what = MSG_SHOW_SEARCH_RESULT;
				pin_address = res.strAddr;
				Bundle data = new Bundle();
				data.putString(Constants.PIN_ADDRESS, res.strAddr);
				msg.setData(data);
				handler.sendMessage(msg);
			}
			public void onGetPoiResult(MKPoiResult res, int type, int error) {
			}
			public void onGetDrivingRouteResult(MKDrivingRouteResult res, int error) {
			}
			public void onGetTransitRouteResult(MKTransitRouteResult res, int error) {
			}
			public void onGetWalkingRouteResult(MKWalkingRouteResult res, int error) {
			}
			public void onGetBusDetailResult(MKBusLineResult result, int iError) {
			}
			public void onGetSuggestionResult(MKSuggestionResult res, int arg1) {
			}
        });
		
        // 如果是新建，定位手持者的当前位置，如果是修改，定位活动的地理位置
		if (isDataNull) {
			Log.e(TAG, "新建活动，开始定位");
			locMyPosition();
		} else {
	        mapCtrl.setCenter(pin_point);
			setPopView(pin_overlay_item);
			mapOverlays.add(pin_overlay);
			hasPin = true;
		}
        
        search_btn = (Button) findViewById(R.id.search_btn);
        search_btn.setOnClickListener(this);
        location_btn = (Button) findViewById(R.id.location_btn);
        location_btn.setOnClickListener(this);
        save_btn = (Button) findViewById(R.id.save_btn);
        save_btn.setOnClickListener(this);
	}
	
	// 初始化PopView
	private void initPopView() {
    	if(null == popView){
			popView = getLayoutInflater().inflate(R.layout.overlay_popup, null);
			mapView.addView(popView, new MapView.LayoutParams(
					MapView.LayoutParams.WRAP_CONTENT,
					MapView.LayoutParams.WRAP_CONTENT, null,
					MapView.LayoutParams.BOTTOM_CENTER));
			popView.setVisibility(View.GONE);
    	} else {
    		Log.e(TAG, "PopView 不是为空");
    	}
    }
	
	// 显示从pScrEventInfo获取的地理信息
	private void setPopView(OverlayItem item) {
		MapView.LayoutParams params = (MapView.LayoutParams) popView.getLayoutParams();
		params.x = pin_overlay.layout_x;	//Y轴偏移
		params.y = pin_overlay.layout_y;	//Y轴偏移
		params.point = item.getPoint();
		
		mapView.updateViewLayout(popView,
                new MapView.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT,
                		item.getPoint(), MapView.LayoutParams.BOTTOM_CENTER));
		
		TextView title_TextView = (TextView) popView.findViewById(R.id.loc_title);
		title_TextView.setText(item.getTitle());
		
		TextView desc_TextView = (TextView) popView.findViewById(R.id.loc_text);
		if(null == item.getSnippet() || "".equals(item.getSnippet())) {
			desc_TextView.setVisibility(View.GONE);
		}else{
			String desc = item.getSnippet();
			desc_TextView.setText(desc);
			desc_TextView.setVisibility(View.VISIBLE);
		}
		
		RelativeLayout button = (RelativeLayout) popView.findViewById(R.id.loc_btn);
		button.setOnClickListener(this);
		mapView.updateViewLayout(popView, params);
		popView.setVisibility(View.VISIBLE);
		pin_overlay.addOverlay(item);
		mapCtrl.animateTo(item.getPoint());
		pin_overlay.updateOverlay();
	}
	
	private void getBundleData() {
		Bundle bundle = this.getIntent().getExtras();
		double loc_point[] = bundle.getDoubleArray(Constants.PIN_GEOPOINT);
		pin_address = bundle.getString(Constants.PIN_ADDRESS);
		if (loc_point[0] == -90) {
			isDataNull = true;
		} else {
			isDataNull = false;
			pin_point = new GeoPoint((int)(loc_point[0] * 1e6), (int)(loc_point[1] * 1e6));
			pin_overlay_item = new OverlayItem(pin_point, "活动地址", pin_address);
		}
	}
	
	// 定位当前位置
	public void locMyPosition() {
		Log.e(TAG, "定位我的位置");
		app.mBMapMan.getLocationManager().requestLocationUpdates(mLocationListener);
		myloc_overlay.enableMyLocation();
		Log.e(TAG, "locMyPosition完成");
	}
	
	// 搜索功能暂时放下
	protected Dialog onCreateDialog(int id) {
		switch (id) {
        case DIALOG_SEARCH_RESULT :
        	return new AlertDialog.Builder(pScrChooseLocation.this)
        		.setTitle("请选择你要")
        		.setItems(null, new DialogInterface.OnClickListener() {
					@Override
					public void onClick(DialogInterface dialog, int which) {
						// TODO Auto-generated method stub
						
					}
				}).create();
		}
		return null;
	}
	
	@Override
	protected boolean isRouteDisplayed() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void onClick(View v) {
		// TODO Auto-generated method stub
		if (v == search_btn) {
			Log.e(TAG, "点击了 搜索");
			showDialog(DIALOG_SEARCH_RESULT);
		} else if (v == location_btn) {
			// 当点击
			myloc_overlay.disableMyLocation();
			app.mBMapMan.getLocationManager().requestLocationUpdates(mLocationListener);
			myloc_overlay.enableMyLocation();
			Toast.makeText(getApplicationContext(), "定位中...", Toast.LENGTH_LONG).show();
		} else if (v == save_btn) {
			Intent intent = new Intent(pScrChooseLocation.this, pScrEventInfo.class);
			// 有图钉，就用图钉的地理信息，没有图钉，就用当前位置，即定位获取的地理信息
			Bundle data = new Bundle();
			double event_point[] = new double[2];
			String event_address = "";
			if (!isCurLocate) {
				Log.e(TAG, "保存返回pin_point = " + pin_point.getLongitudeE6() + ", " + pin_point.getLatitudeE6());
				event_point[0] = this.pin_point.getLatitudeE6();
				event_point[1] = this.pin_point.getLongitudeE6();
				event_address = this.pin_address;
			} else {
				Log.e(TAG, "保存返回myloc_point = " + myloc_point.getLongitudeE6() + ", " + myloc_point.getLatitudeE6());
				event_point[0] = this.myloc_point.getLatitudeE6();
				event_point[1] = this.myloc_point.getLongitudeE6();
				event_address = this.pin_address;
			}
			
			data.putDoubleArray("loc_point", event_point);
			data.putString("loc_addr", event_address);
			intent.putExtras(data);
			setResult(RESULT_OK, intent);   
	        finish();
		}
	}
	
	@Override
	protected void onPause() {
		BMapApp app = (BMapApp)this.getApplication();
		myloc_overlay.disableMyLocation();
		myloc_overlay.disableCompass(); // 关闭指南针
		if(app.mBMapMan != null)
			app.mBMapMan.stop();
		super.onPause();
	}
	@Override
	protected void onResume() {
		BMapApp app = (BMapApp)this.getApplication();
		//app.mBMapMan.getLocationManager().requestLocationUpdates(mLocationListener);
		app.mBMapMan.start();
		super.onResume();
	}
}
